﻿using System.Collections.Generic;
using System.Linq;
using Sinacor.Infra.Service.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.Infra.Service.ExceptionHandling;
using Sinacor.Infra.Service.Validation.BusinessRules;

namespace Sinacor.Servico.Bovespa.Corretagem.BusinessLogic
{
    /// <summary>
    /// Lógica de negócios de verificações de políticas de corretagens
    /// </summary>
    public class VerificacaoPolitica : BaseBusinessLogic
    {
        #region Atributos

        private int _erroObjetoNulo = 109531;
        ResourceAccess.VerificacaoPolitica _raVerificacaoPolitica = null;

        #endregion

        #region Construtor

        /// <summary>
        /// Construtor VerificacaoPolitica
        /// </summary>
        public VerificacaoPolitica()
            : base()
        {
            this._raVerificacaoPolitica = new ResourceAccess.VerificacaoPolitica();
        }

        #endregion

        #region Propriedades

        /// <summary>
        /// Objeto Nulo
        /// </summary>
        public int ErroObjetoNulo
        {
            get
            {
                return _erroObjetoNulo;
            }
            set
            {
                _erroObjetoNulo = value;
            }
        }
        #endregion

        #region Métodos

        /// <summary>
        /// Consulta lista de verificações de politicas de corretagens conforme filtro.
        /// </summary>
        /// <param name="entity"></param>
        public List<BusinessEntity.VerificacaoPolitica> ConsultarVerificacoesPoliticas(BusinessEntity.Parameter.FiltroVerificacaoPolitica entity)
        {
            if (entity != null)
                return this._raVerificacaoPolitica.ConsultarVerificacoesPoliticas(entity);
            else
                throw new BusinessException(ErroObjetoNulo);
        }

        /// <summary>
        /// Exclui todas as verificações de uma política de corretagem.
        /// 
        /// Obs: Basta informar o codigo e a data inicial da política em questão para
        /// efetuar as exclusões.
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirTodasVerificacoesPolitica(BusinessEntity.Parameter.FiltroVerificacaoPolitica entity)
        {
            if (entity != null && entity.CodigoPolitica.HasValue && entity.DataInicial.HasValue)
            {
                this._raVerificacaoPolitica.ExcluirTodasVerificacoesPolitica(entity);
            }
            else
            {
                throw new BusinessException(ErroObjetoNulo);
            }
        }

        /// <summary>
        /// Duplica a lista de verificações para nova política de corretagem
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="novaPolitica"></param>
        public void DuplicarVerificacoesPolitica(BusinessEntity.Parameter.FiltroPoliticaCorretagemChave entity, ref BusinessEntity.PoliticaCorretagem novaPolitica)
        {
            if (entity != null && novaPolitica != null)
            {
                this._raVerificacaoPolitica.DuplicarVerificacoesPolitica(entity, new BusinessEntity.Parameter.FiltroPoliticaCorretagemChave { Codigo = novaPolitica.Codigo, DataInicial = novaPolitica.DataInicial });
                novaPolitica.Verificacoes = this.ConsultarVerificacoesPoliticas(new BusinessEntity.Parameter.FiltroVerificacaoPolitica { CodigoPolitica = novaPolitica.Codigo, DataInicial = novaPolitica.DataInicial });
            }
            else
            {
                throw new BusinessException(ErroObjetoNulo);
            }
        }

        /// <summary>
        /// Incluir uma verificacao de política de corretagem
        /// </summary>
        /// <param name="entity"></param>
        public void IncluirVerificacaoPolitica(BusinessEntity.VerificacaoPolitica entity)
        {
            BusinessRulesValidator validador = null;
            BusinessRuleValidation.ValidaInclusaoVerificacaoPolitica verificaInclusaoVerificacaoPolitica = null;

            if (entity != null)
            {
                verificaInclusaoVerificacaoPolitica = new BusinessRuleValidation.ValidaInclusaoVerificacaoPolitica();
                verificaInclusaoVerificacaoPolitica.EntityToValidate = entity;
                validador = new BusinessRulesValidator();
                validador.AddValidation("VerificaInclusaoVerificacaoPolitica", verificaInclusaoVerificacaoPolitica);

                validador.Validate();

                this._raVerificacaoPolitica.IncluirVerificacaoPolitica(entity);
            }
            else
            {
                throw new BusinessException(ErroObjetoNulo);
            }
        }

        /// <summary>
        /// Inclui uma lista de verificações de políticas de corretagem
        /// </summary>
        /// <param name="entityList"></param>
        public void IncluirVerificacoesPoliticas(List<BusinessEntity.VerificacaoPolitica> entityList)
        {
            if (entityList != null)
            {
                if (entityList.Count > 0)
                {
                    foreach (BusinessEntity.VerificacaoPolitica item in entityList)
                    {
                        if (item.Acao == BusinessEntity.Enum.AcaoVerificacaoPolitica.Incluir)
                            this.IncluirVerificacaoPolitica(item);
                    }
                }
            }
            else
            {
                throw new BusinessException(ErroObjetoNulo);
            }
        }

        /// <summary>
        /// Atualiza a lista de verificações de politicas conforme ação.
        /// </summary>
        /// <param name="entityList"></param>
        public void AtualizarVerificacoesPolitica(List<BusinessEntity.VerificacaoPolitica> entityList)
        {
            List<BusinessEntity.VerificacaoPolitica> listaVerificacoesExcluir = null;
            List<BusinessEntity.VerificacaoPolitica> listaVerificacoesIncluir = null;

            if (entityList != null && entityList.Count > 0)
            {
                //Obtém a lista de Verificações a Excluir
                foreach (BusinessEntity.VerificacaoPolitica entidade in entityList)
                {
                    listaVerificacoesExcluir = (from verificacao in entityList where verificacao.Acao == BusinessEntity.Enum.AcaoVerificacaoPolitica.Excluir select verificacao).ToList<BusinessEntity.VerificacaoPolitica>();
                }

                if (listaVerificacoesExcluir.Count > 0)
                {
                    this.ExcluirVerificacoesPoliticas(listaVerificacoesExcluir);

                    //Obtém a lista de Verificações a Incluir
                    ObterListaVerificacoesInclusao(entityList, listaVerificacoesIncluir);
                }
                else
                {
                    //Obtém a lista de Verificações a Incluir
                    ObterListaVerificacoesInclusao(entityList, listaVerificacoesIncluir);
                }
            }
        }

        private void ObterListaVerificacoesInclusao(List<BusinessEntity.VerificacaoPolitica> entityList, List<BusinessEntity.VerificacaoPolitica> listaVerificacoesIncluir)
        {
            foreach (BusinessEntity.VerificacaoPolitica entidade in entityList)
            {
                listaVerificacoesIncluir = (from verificacao in entityList where verificacao.Acao == BusinessEntity.Enum.AcaoVerificacaoPolitica.Incluir select verificacao).ToList<BusinessEntity.VerificacaoPolitica>();
            }

            if (listaVerificacoesIncluir.Count > 0)
            {
                this.IncluirVerificacoesPoliticas(listaVerificacoesIncluir);
            }
        }

        /// <summary>
        /// Exclui uma verificação de politica de corretagem
        /// </summary>
        /// <param name="entity"></param>
        public void ExcluirVerificacaoPolitica(BusinessEntity.VerificacaoPolitica entity)
        {
            if (entity != null)
            {
                this._raVerificacaoPolitica.ExcluirVerificacaoPolitica(entity);
            }
            else
            {
                throw new BusinessException(ErroObjetoNulo);
            }
        }

        /// <summary>
        /// Exclui uma lista de verificações de politicas de corretagem
        /// </summary>
        /// <param name="entityList"></param>
        public void ExcluirVerificacoesPoliticas(List<BusinessEntity.VerificacaoPolitica> entityList)
        {
            if (entityList != null && entityList.Count > 0)
            { 
                //Obtém a lista de Verificações a Excluir
                foreach (BusinessEntity.VerificacaoPolitica entidade in entityList)
                {
                    this.ExcluirVerificacaoPolitica(entidade);
                }
            }
        }

        #endregion
    }
}